home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 48 / Amiga Format CD48 (1999-12-13)(Future Publishing)(GB)(Track 1 of 2)[!][issue 2000-01].iso / -serious- / programming / c / supralib / developer / source / makenewimg.c < prev    next >
C/C++ Source or Header  |  1999-11-01  |  5KB  |  161 lines
  1. /****** MakeNewImg *************************************************
  2. *
  3. *   NAME
  4. *       MakeNewImg -- Remap an image to any new colours (V10)
  5. *
  6. *   SYNOPSIS
  7. *       newImage = MakeNewImg(oldImage, palette)
  8. *
  9. *       struct Image * = MakeNewImg(struct Image *, ULONG *);
  10. *
  11. *   FUNCTION
  12. *       This function creates a new clone image of a provided
  13. *       image, and it remaps the new image according to a provided
  14. *       pen colour list.
  15. *       This is very useful when you need your image to use
  16. *       specific colours anywhere in the available palette.
  17. *       (e.g. you obtained some free pens from a palette, and
  18. *       you want your image to be shown with those pens).
  19. *       It is possible to modify an image's pens with PlanePick and
  20. *       PlaneOnOff fields (see Image structure), but this has a major
  21. *       limitation: most colour combinations are not possible to get.
  22. *
  23. *       If your image has four colours (0,1,2,3), and you want to
  24. *       remap these to (0,16,4,7), you simply call this function,
  25. *       providing it with the image and a new colour map, and a
  26. *       new image will be created for you.
  27. *
  28. *   INPUTS
  29. *       oldImage - pointer to an Image structure to be remapped
  30. *       palette  - pointer to a list of new pens
  31. *
  32. *       A pens list should contain the exact number of pens as
  33. *       an old image uses. (2 if image's depth is 1, 4 if image's
  34. *       depth is 2, etc.). An image's colour 0 will be remapped to the
  35. *       first pen on the list, image's colour 1 will be remapped to
  36. *       the second pen on the list and so on.
  37. *
  38. *   RESULT
  39. *       newImage - pointer to a newly initialized remapped old image's
  40. *                  clone. If there is not enough memory, newImage will
  41. *                  be NULL.
  42. *       IMPORTANT: If a new image was created you have to call
  43. *       FreeNewImg() to free the allocated memory, when you no longer
  44. *       need to use it!
  45. *
  46. *   EXAMPLE
  47. *
  48. *       We have a depth 2 image (4 colours), and we want to use pens
  49. *       0,16,4,7 instead of 0,1,2,3:
  50. *
  51. *
  52. *       struct Image OldImage = {
  53. *           ....    \* This is a data of our original image *\
  54. *
  55. *       struct Image *NewImage;
  56. *       ULONG pal[] = {0, 16, 4, 7}; \* The new pen list *\
  57. *
  58. *       if (NewImage = MakeNewImg(&OldImage, &pal[0])) {
  59. *          DrawImage(rp, NewImage);
  60. *          FreeNewImg(NewImage);    \* We will no longer use it *\
  61. *       }
  62. *
  63. *   NOTE
  64. *       A new image's depth will change to a depth that can hold
  65. *       the largest pen number from a pens list. It does not have
  66. *       any smart routine to check if the depth can be optimized
  67. *       down, by altering PlanePick and PlaneOnOff, yet.
  68. *       Bear in mind that if you provide a pen 255, then a new image's
  69. *       depth will be at least 8.
  70. *
  71. *       You MUST free a new image with FreeNewImg() when it's no longer
  72. *       needed!
  73. *
  74. *       This function can take much time when remapping larger images
  75. *       with more depths.
  76. *
  77. *   BUGS
  78. *       None found.
  79. *
  80. *   SEE ALSO
  81. *       FreeNewImg()
  82. *
  83. **********************************************************************/
  84.  
  85. #include<proto/exec.h>
  86. #include<exec/exec.h>
  87. #include<intuition/intuition.h>
  88.  
  89. /******************************************** excluded for vbcc
  90.  * char __asm mkImg(register __a1 UWORD *,
  91.  *                  register __a2 UWORD *,
  92.  *                  register __a3 ULONG *,
  93.  *                  register __d4 LONG,
  94.  *                  register __d5 LONG,
  95.  *                  register __d6 LONG);
  96.  * 
  97.  ******************************************** and now, the replacement */
  98.  
  99. char mkImg(UWORD *, UWORD *, ULONG *, LONG, LONG, LONG);
  100.  
  101. struct Image *MakeNewImg(struct Image *img, ULONG *pal)
  102. {
  103.     struct Image *newimg;
  104.     UWORD i, num, max=0, dep;
  105.     WORD wid;
  106.     LONG mask=0;
  107.  
  108.     newimg = AllocMem(sizeof(struct Image), 0);
  109.     if (newimg)
  110.     {
  111.         dep = img->Depth;
  112.         num = 1<<dep;
  113.  
  114.         /* Get the maximum palette color entry */
  115.         for (i=0; i<num; i++) if (pal[i] > max) max = pal[i];
  116.  
  117.         /* Get a destination depth */
  118.         while (max>>dep > 0) dep++;
  119.  
  120.         /* Width must be word aligned */
  121.         i=0;
  122.         wid = img->Width;
  123.         while(i < wid) i+=16;
  124.         wid = i; /* NOTE: Width=0 is not considered yet */
  125.  
  126.         /* Alloc Planes */
  127.         newimg->ImageData = AllocMem(img->Height*wid*dep/8, MEMF_CHIP | MEMF_CLEAR);
  128.         if (newimg->ImageData)
  129.         {
  130.             /* Fill newimg fields */
  131.  
  132.             newimg->Depth = dep;
  133.             newimg->Height = img->Height;
  134.             newimg->Width = img->Width;
  135.             newimg->LeftEdge = img->LeftEdge;
  136.             newimg->TopEdge = img->TopEdge;
  137.             for (i=0; i<dep; i++) mask |= 1<<i;
  138.             newimg->PlanePick = mask;
  139.             newimg->PlaneOnOff = 0;
  140.             newimg->NextImage = NULL;
  141.  
  142.             mkImg(img->ImageData, newimg->ImageData, pal, img->Height*wid/8, img->Depth, dep);
  143.  
  144.         }
  145.     }
  146.  
  147.     if (newimg)
  148.     {
  149.         if (newimg->ImageData)
  150.         {
  151.             return(newimg);
  152.         }
  153.         else
  154.         {
  155.             FreeMem(newimg, sizeof(struct Image));
  156.             return(NULL);
  157.         }
  158.     }
  159.     else return(NULL);
  160. }
  161.